public class Practice {

    public static void main1(String[] args) {
        //类和对象
        //面向对象？面向过程
        //如何定义一个类
        //如何实例化一个对象
        //如何通过对象访问对象的成员属性，成员方法
        //this引用
        //构造方法

        //引用指向null代表什么---》引用不指向任何对象
//        引用指向引用可以吗--》i引用指向另一个引用指向的对象
//        一个引用是否可以指向多个对象

        //对类的细节进行隐藏，提供公开的接口来和数据进行交互


    }

    public static void main5(String[] args) {
        Student s1 = new Student("李煜微1",20);
        Student s2 = new Student("李煜微2",20);
        Student s3 = new Student("李煜微3",20);
        Student s4 = null;
        System.out.println(s4.classRoom);
        Student.func();
        s1.func();
    }

    public static void main(String[] args) {
        //继承和多态
//        在面向对象的语言中，也存在继承的思想
        Dog dog = new Dog();
        dog.name = "坦克";
        dog.eat();
        dog.bark();

        Cat cat = new Cat();
        cat.name = "小花";
        cat.eat();
        cat.mew();

    }
}

class Person {
    private String name;
    private int age;
    private void eat () {
        System.out.println("eat");
    }
    public void play() {
        System.out.println("play");
    }



    //快捷创造构造方法，右键，generate constructor ctrl选择成员
    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(int age) {
        this.age = age;
    }
//快捷键创造get和set  右键，generate get和set ctrl选择成员
    public String getname() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println(this.name);
        System.out.println(this.age);
    }
    //name和eat这两个方法已经被封装起来了，使用privat
    //e关键字进行修饰。此时，name和eat权限就变小了，只能在类中访问
}


class Student {
    private String name;
    private int age;
    public static String classRoom = "107java" ;
    //班级所有人的班级都是一样的，所以不需要

    public void doClass () {
        System.out.println("shangke");
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void func() {
        System.out.println("func");
    }

//    对于我们的成员方法
//    静态成员方法 类方法
//    非静态成员方法/普通成员方法
}
//加了static之后，每个对象的成员变量就没有classRo
//该变量被放到方法区


//静态变量不依赖对象

//被static修饰的都不属于对象，都可以通过类直接使用

//静态方法不能直接调用非静态方法

//1.在静态方法内部不能直接调用非静态成员方法
//2. 在静态方法内部不能直接调用非静态成员变量
//非静态成员方法依赖于对象，需要通过对象来调用，只要是非静态的数据成员，都需要通过对象的引用才能调用
//3.静态方法里面不能直接使用this

//普通成员方法是可以使用静态1成员方法的
//静态和非静态谁的权限比较大？？？





//总结：如果都是非静态的，那么看定义的顺序，那么最后就是那个值
//
//实例代码块：在构造方法之前对成员变量赋值

//执行顺序

//静态代码块：只要类被加载，静态代码块都会被执行。静态代码块只会被执行一次
//非静态代码块：
//构造方法:

//内部类

class A {
    public String name;
    public int age;

    public void eat() {
        System.out.println("eat");
    }

}

class B extends A{
    public void bark() {
        System.out.println("wang");
    }

}


class C extends A{
    public void mew() {
        System.out.println("miao");
    }

}
class Dog {
    public String name;
    public int age;

    public void eat() {
        System.out.println("eat");
    }

    public void bark() {
        System.out.println("wang");
    }
}

class Cat {
    public String name;
    int age;

    public void eat() {
        System.out.println("eat");
    }

    public void mew() {
        System.out.println("miao");
    }
}

//将共性的东西抽取出来，放在父类中

//继承最大的意义，就是实现代码复用
//is_a的关系  子类  is a  父类
//dog is a animal
//cat is a animal
//继承关键字：extends

//子类/派生类
//父类/基类/超类

//子类会继承父类的成员变量和成员方法

//java中是单继承1，一个子类只能继承一个父类，不能实现多继承
//一个父类可以被多个子类继承，可以派生出多个子类

